﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;

namespace CityGames
{
    public class CopiaFisica
    {
        private int codigo;
        private string nombreJuego;
        private string plataformaJuego;
        static private CADCopiaFisica cadCopiaFisicaJuego = new CADCopiaFisica();

        public int Codigo
        {
            get { return codigo; }
            set { codigo = value; }
        }

        public string NombreJuego
        {
            get { return nombreJuego; }
            set { nombreJuego = value; }
        }

        public string PlataformaJuego
        {
            get { return plataformaJuego; }
            set { plataformaJuego = value; }
        }

        /************************************************** Funciones de Marcos **************************************************/

        /// <summary>
        /// Constructor por defecto de la clase CopiaFisica.
        /// Inicializa codigo a 0 y nombre y plataforma a "".
        /// </summary>
        public CopiaFisica()
        {
            codigo = 0;
            nombreJuego = "";
            plataformaJuego = "";
        }

        /// <summary>
        /// Función para obtener el número de todas las copias físicas de un juego determinado por parámetro
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se desea obtener el número de copias físicas</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se desea obtener el número de copias físicas</param>
        /// <returns>
        /// Devuelve el número de copias físicas del juego especificado por parámetro</returns>
        public int ObtenerTodasLasCopiasFisicas(string nombre, string plataforma)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicas(nombre, plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos de todas las copias físicas de un juego paginadas
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se desean obtener los datos de las copias físicas paginadas</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se desean obtener los datos de las copias físicas paginadas</param>
        /// <param name="desde">
        /// Número correspondiente a la fila desde la cual se comenzaran a obtener los datos de la Base de Datos para la paginación</param>
        /// <param name="hasta">
        /// Número correspondiente a la fila hasta la cual se obtendrán los datos de la Base de Datos para la paginación</param>
        /// <returns>
        /// Devuelve un DataSet con los datos de las copias físicas paginadas dentro de una tabla denominada "CopiasFisicasPaginadas"</returns>
        public DataSet ObtenerTodasLasCopiasFisicasPaginadas(string nombre, string plataforma, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicasPaginadas(nombre, plataforma, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Función para obtener el número de copias físicas para alquilar de un juego especificado por parámetro
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se obtendrá el número de copias físicas para alquilar</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se obtendrá el número de copias físicas para alquilar</param>
        /// <returns>
        /// Devuelve el número de copias físicas para alquilar del juego especificado por parámetro</returns>
        public int ObtenerTodasLasCopiasFisicasParaAlquilar(string nombre, string plataforma)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicasParaAlquilar(nombre, plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos de las copias físicas para alquilar del juego especificado por parámetro paginadas
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se desea obtener los datos de las copias físicas para alquilar paginadas</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se desea obtener los datos de las copias físicas para alquilar paginadas</param>
        /// <param name="desde">
        /// Número correspondiente a la fila desde la cual se comenzaran a obtener los datos de la Base de Datos para la paginación</param>
        /// <param name="hasta">
        /// Número correspondiente a la fila hasta la cual se obtendrán los datos de la Base de Datos para la paginación</param>
        /// <returns>
        /// Devuelve un DataSet con los datos de las copias físicas para alquilar paginadas dentro de una tabla denominada "CopiasAlquilerPaginadas"</returns>
        public DataSet ObtenerTodasLasCopiasFisicasParaAlquilarPaginadas(string nombre, string plataforma, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicasParaAlquilarPaginadas(nombre, plataforma, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Función para obtener el número de copias físicas nuevas para vender de un juego especificado por parámetro
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se obtendrá el número de copias físicas nuevas para vender</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se obtendrá el número de copias físicas nuevas para vender</param>
        /// <returns>
        /// Devuelve el número de copias físicas nuevas para vender del juego especificado por parámetro</returns>
        public int ObtenerTodasLasCopiasFisicasNuevas(string nombre, string plataforma, bool noVendida)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicasNuevas(nombre, plataforma, noVendida);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos de las copias físicas nuevas para vender del juego especificado por parámetro paginadas
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se desea obtener los datos de las copias físicas nuevas para vender paginadas</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se desea obtener los datos de las copias físicas nuevas para vender paginadas</param>
        /// <param name="desde">
        /// Número correspondiente a la fila desde la cual se comenzaran a obtener los datos de la Base de Datos para la paginación</param>
        /// <param name="hasta">
        /// Número correspondiente a la fila hasta la cual se obtendrán los datos de la Base de Datos para la paginación</param>
        /// <returns>
        /// Devuelve un DataSet con los datos de las copias físicas nuevas para vender paginadas dentro de una tabla denominada "CopiasNuevasPaginadas"</returns>
        public DataSet ObtenerTodasLasCopiasFisicasNuevasPaginadas(string nombre, string plataforma, bool noVendida, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicasNuevasPaginadas(nombre, plataforma, noVendida, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Función para obtener el número de copias físicas de segunda mano para vender de un juego especificado por parámetro
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se obtendrá el número de copias físicas de segunda mano para vender</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se obtendrá el número de copias físicas de segunda mano para vender</param>
        /// <returns>
        /// Devuelve el número de copias físicas de segunda mano para vender del juego especificado por parámetro</returns>
        public int ObtenerTodasLasCopiasFisicasSegundaMano(string nombre, string plataforma, bool noVendida)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicasSegundaMano(nombre, plataforma, noVendida);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos de las copias físicas de segunda mano para vender del juego especificado por parámetro paginadas
        /// </summary>
        /// <param name="nombre">
        /// Nombre del juego del cual se desea obtener los datos de las copias físicas de segunda mano para vender paginadas</param>
        /// <param name="plataforma">
        /// Plataforma del juego del cual se desea obtener los datos de las copias físicas de segunda mano para vender paginadas</param>
        /// <param name="desde">
        /// Número correspondiente a la fila desde la cual se comenzaran a obtener los datos de la Base de Datos para la paginación</param>
        /// <param name="hasta">
        /// Número correspondiente a la fila hasta la cual se obtendrán los datos de la Base de Datos para la paginación</param>
        /// <returns>
        /// Devuelve un DataSet con los datos de las copias físicas de segunda mano para vender paginadas dentro de una tabla denominada "CopiasSegundaManoPaginadas"</returns>
        public DataSet ObtenerTodasLasCopiasFisicasSegundaManoPaginadas(string nombre, string plataforma, bool noVendida, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.ObtenerTodasLasCopiasFisicasSegundaManoPaginadas(nombre, plataforma, noVendida, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Función para insertar un número determinado de copias físicas del juego especificado por parámetro del tipo especificado, a la cual se le asignará un Código consecutivo empezando por el más alto presente en la Base de Datos + 1
        /// </summary>
        /// <param name="numeroCopias">
        /// Número de copias que se desean insertar</param>
        /// <param name="tipo">
        /// Tipo de las copias que se desean insertar. El valor "Alquiler" corresponde a copias para alquilar, "Nuevas" corresponde a copias nuevas para vender y "Segunda Mano" corresponde a copias de segunda mano para vender</param>
        /// <param name="nombre">
        /// Nombre del juego al cual corresponden las copias físicas</param>
        /// <param name="plataforma">
        /// Plataforma del juego a la cual corresponden las copias físicas</param>
        /// <returns>
        /// Devuelve True si se han podido realizar todas las inserciones, False en caso contrario</returns>
        public bool InsertarCopias(int numeroCopias, string tipo, string nombre, string plataforma)
        {
            bool resultado = false;

            try
            {
                resultado = cadCopiaFisicaJuego.InsertarCopias(numeroCopias, tipo, nombre, plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función que devuelve el valor del código más alto de las copias físicas de la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve el valor numérico correspondiente al valor más alto del código de las copias físicas de la Base de Datos. Devuelve 0 si no existen copias</returns>
        public int ObtenerCodigoMaximo()
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.ObtenerCodigoMaximo();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para borrar de la base de datos la copia física correspondiente al código especificado por parámetro
        /// </summary>
        /// <param name="codigo">
        /// Código de la copia física que se desea eliminar de la Base de Datos</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningun error durante la eliminación, False en caso contrario</returns>
        public bool BorrarCopiaFisica(int codigo)
        {
            bool resultado = false;

            try
            {
                resultado = cadCopiaFisicaJuego.BorrarCopiaFisica(codigo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /************************************************** Fin Funciones de Marcos **************************************************/
        /************************************************** Funciones de Ruben **************************************************/

        /// <summary>
        /// Funcion que devuelve el numero de copias fisicas de un juego almacenado en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>        
        /// <returns>
        /// El numero de copias
        /// </returns>
        public int NumeroCopiasFisicas(string nombre, string plataforma)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.NumeroCopiasFisicas(nombre, plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion que devuelve las copias fisicas de un juego paginadas almacenadas en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>
        /// <param name="desde">
        /// Entero que indica desde que número de fila se desea mostrar</param>
        /// <param name="hasta">
        /// Entero que indica hasta que número de fila se desea mostrar</param>
        /// <returns>
        /// Las copias paginadas
        /// </returns>
        public DataSet CopiasFisicasPaginadas(string nombre, string plataforma, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.CopiasFisicasPaginadas(nombre, plataforma, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Funcion que devuelve el numero de copias fisicas de alquiler de un juego almacenado en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>        
        /// <returns>
        /// El numero de copias
        /// </returns>
        public int NumeroCopiasFisicasParaAlquilar(string nombre, string plataforma)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.NumeroCopiasFisicasParaAlquilar(nombre, plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion que devuelve las copias fisicas de alquiler de un juego paginadas almacenadas en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>
        /// <param name="desde">
        /// Entero que indica desde que número de fila se desea mostrar</param>
        /// <param name="hasta">
        /// Entero que indica hasta que número de fila se desea mostrar</param>
        /// <returns>
        /// Las copias paginadas
        /// </returns>
        public DataSet CopiasFisicasParaAlquilarPaginadas(string nombre, string plataforma, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.CopiasFisicasParaAlquilarPaginadas(nombre, plataforma, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Funcion que devuelve el numero de copias fisicas nuevas de un juego almacenado en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>        
        /// <returns>
        /// El numero de copias
        /// </returns>
        public int NumeroCopiasFisicasNuevas(string nombre, string plataforma)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.NumeroCopiasFisicasNuevas(nombre, plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion que devuelve las copias fisicas nuevas de un juego paginadas almacenadas en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>
        /// <param name="desde">
        /// Entero que indica desde que número de fila se desea mostrar</param>
        /// <param name="hasta">
        /// Entero que indica hasta que número de fila se desea mostrar</param>
        /// <returns>
        /// Las copias paginadas
        /// </returns>
        public DataSet CopiasFisicasNuevasPaginadas(string nombre, string plataforma, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.CopiasFisicasNuevasPaginadas(nombre, plataforma, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Funcion que devuelve el numero de copias fisicas de segunda mano de un juego almacenado en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>        
        /// <returns>
        /// El numero de copias
        /// </returns>
        public int NumeroCopiasFisicasSegundaMano(string nombre, string plataforma)
        {
            int resultado = 0;

            try
            {
                resultado = cadCopiaFisicaJuego.NumeroCopiasFisicasSegundaMano(nombre, plataforma);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion que devuelve las copias fisicas de segunda mano de un juego paginadas almacenadas en la BD
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>
        /// <param name="plataforma">
        /// La plataforma del juego</param>
        /// <param name="desde">
        /// Entero que indica desde que número de fila se desea mostrar</param>
        /// <param name="hasta">
        /// Entero que indica hasta que número de fila se desea mostrar</param>
        /// <returns>
        /// Las copias paginadas
        /// </returns>
        public DataSet CopiasFisicasSegundaManoPaginadas(string nombre, string plataforma, int desde, int hasta)
        {
            DataSet copiasFisicasPaginadas = new DataSet();

            try
            {
                copiasFisicasPaginadas = cadCopiaFisicaJuego.CopiasFisicasSegundaManoPaginadas(nombre, plataforma, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return copiasFisicasPaginadas;
        }

        /// <summary>
        /// Funcion que devuelve los datos de un alquiler
        /// </summary>        
        /// <param name="codigo">
        /// El codigo de la copia del juego</param>
        /// <returns>
        /// Un dataset con la informacion del alquiler de la copia
        /// </returns>
        public DataSet ObtenerDatosAlquiler(string codigo)
        {
            DataSet datosAlquiler = new DataSet();

            try
            {
                datosAlquiler = cadCopiaFisicaJuego.ObtenerDatosAlquiler(codigo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return datosAlquiler;
        }

        /// <summary>
        /// Funcion que cambia el estado de alquiler de una copia a devuelto
        /// </summary>        
        /// <param name="codigo">
        /// El codigo de la copia del juego</param>       
        /// <returns>
        /// Un booleano que indica si se ha devuelto correctamente
        /// </returns>
        public bool DevolverJuego(string codigo)
        {
            bool ok = false;

            try
            {
                ok = cadCopiaFisicaJuego.DevolverJuego(codigo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ok;
        }

        /// <summary>
        /// Funcion que cambia el estado de alquiler de una copia a alquilada
        /// </summary>        
        /// <param name="codigo">
        /// El codigo de la copia del juego</param>
        /// <param name="socio">
        /// El dni del socio</param>
        /// <returns>
        /// Un booleano que indica si se ha alquilado correctamente
        /// </returns>
        public bool SetCopiaAlquilada(string codigo, string socio)
        {
            bool ok = false;

            try
            {
                ok = cadCopiaFisicaJuego.SetCopiaAlquilada(codigo, socio);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ok;
        }

        /// <summary>
        /// Funcion que cambia el estado de una copia a vendida
        /// </summary>        
        /// <param name="codigo">
        /// El codigo de la copia del juego</param>      
        /// <param name="socio">
        /// El socio al que se le ha vendido</param> 
        /// <param name="precio">
        /// El precio por el que se ha vendido la copia del juego</param>      
        /// <returns>
        /// Un booleano que indica si se ha modificado la BD correctamente
        /// </returns>
        public bool SetCopiaVendida(string codigo, string socio, string precio)
        {
            bool ok = false;

            try
            {
                ok = cadCopiaFisicaJuego.SetCopiaVendida(codigo, socio, precio);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ok;
        }

        /// <summary>
        /// Funcion que devuelve el numero de copia de un juego
        /// </summary>        
        /// <param name="nombre">
        /// El nombre del juego</param>      
        /// <param name="plataforma">
        /// La plataforma del juego</param> 
        /// <param name="tipo">
        /// El tipo de juego (nuevo o segunda mano)</param>      
        /// <returns>
        /// El codigo de la copia
        /// </returns>
        public string GetNumCopia(string nombre, string plataforma, string tipo)
        {
            string numCopia = "";

            try
            {
                numCopia = cadCopiaFisicaJuego.GetNumCopia(nombre, plataforma, tipo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return numCopia;
        }
        /**************************************************Fin Funciones de Ruben **************************************************/
    }
}
